home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / sysconfig.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  17KB  |  585 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. """Provide access to Python's configuration information.
  5.  
  6. """
  7. import sys
  8. import os
  9. from os.path import pardir, realpath
  10. _INSTALL_SCHEMES = {
  11.     'posix_prefix': {
  12.         'stdlib': '{base}/lib/python{py_version_short}',
  13.         'platstdlib': '{platbase}/lib/python{py_version_short}',
  14.         'purelib': '{base}/lib/python{py_version_short}/site-packages',
  15.         'platlib': '{platbase}/lib/python{py_version_short}/site-packages',
  16.         'include': '{base}/include/python{py_version_short}',
  17.         'platinclude': '{platbase}/include/python{py_version_short}',
  18.         'scripts': '{base}/bin',
  19.         'data': '{base}' },
  20.     'posix_home': {
  21.         'stdlib': '{base}/lib/python',
  22.         'platstdlib': '{base}/lib/python',
  23.         'purelib': '{base}/lib/python',
  24.         'platlib': '{base}/lib/python',
  25.         'include': '{base}/include/python',
  26.         'platinclude': '{base}/include/python',
  27.         'scripts': '{base}/bin',
  28.         'data': '{base}' },
  29.     'nt': {
  30.         'stdlib': '{base}/Lib',
  31.         'platstdlib': '{base}/Lib',
  32.         'purelib': '{base}/Lib/site-packages',
  33.         'platlib': '{base}/Lib/site-packages',
  34.         'include': '{base}/Include',
  35.         'platinclude': '{base}/Include',
  36.         'scripts': '{base}/Scripts',
  37.         'data': '{base}' },
  38.     'os2': {
  39.         'stdlib': '{base}/Lib',
  40.         'platstdlib': '{base}/Lib',
  41.         'purelib': '{base}/Lib/site-packages',
  42.         'platlib': '{base}/Lib/site-packages',
  43.         'include': '{base}/Include',
  44.         'platinclude': '{base}/Include',
  45.         'scripts': '{base}/Scripts',
  46.         'data': '{base}' },
  47.     'os2_home': {
  48.         'stdlib': '{userbase}/lib/python{py_version_short}',
  49.         'platstdlib': '{userbase}/lib/python{py_version_short}',
  50.         'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
  51.         'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
  52.         'include': '{userbase}/include/python{py_version_short}',
  53.         'scripts': '{userbase}/bin',
  54.         'data': '{userbase}' },
  55.     'nt_user': {
  56.         'stdlib': '{userbase}/Python{py_version_nodot}',
  57.         'platstdlib': '{userbase}/Python{py_version_nodot}',
  58.         'purelib': '{userbase}/Python{py_version_nodot}/site-packages',
  59.         'platlib': '{userbase}/Python{py_version_nodot}/site-packages',
  60.         'include': '{userbase}/Python{py_version_nodot}/Include',
  61.         'scripts': '{userbase}/Scripts',
  62.         'data': '{userbase}' },
  63.     'posix_user': {
  64.         'stdlib': '{userbase}/lib/python{py_version_short}',
  65.         'platstdlib': '{userbase}/lib/python{py_version_short}',
  66.         'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
  67.         'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
  68.         'include': '{userbase}/include/python{py_version_short}',
  69.         'scripts': '{userbase}/bin',
  70.         'data': '{userbase}' },
  71.     'osx_framework_user': {
  72.         'stdlib': '{userbase}/lib/python',
  73.         'platstdlib': '{userbase}/lib/python',
  74.         'purelib': '{userbase}/lib/python/site-packages',
  75.         'platlib': '{userbase}/lib/python/site-packages',
  76.         'include': '{userbase}/include',
  77.         'scripts': '{userbase}/bin',
  78.         'data': '{userbase}' } }
  79. _SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include', 'scripts', 'data')
  80. _PY_VERSION = sys.version.split()[0]
  81. _PY_VERSION_SHORT = sys.version[:3]
  82. _PY_VERSION_SHORT_NO_DOT = _PY_VERSION[0] + _PY_VERSION[2]
  83. _PREFIX = os.path.normpath(sys.prefix)
  84. _EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
  85. _CONFIG_VARS = None
  86. _USER_BASE = None
  87.  
  88. def _safe_realpath(path):
  89.     
  90.     try:
  91.         return realpath(path)
  92.     except OSError:
  93.         return path
  94.  
  95.  
  96. if sys.executable:
  97.     _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
  98. else:
  99.     _PROJECT_BASE = _safe_realpath(os.getcwd())
  100. if os.name == 'nt' and 'pcbuild' in _PROJECT_BASE[-8:].lower():
  101.     _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir))
  102. if os.name == 'nt' and '\\pc\\v' in _PROJECT_BASE[-10:].lower():
  103.     _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
  104. if os.name == 'nt' and '\\pcbuild\\amd64' in _PROJECT_BASE[-14:].lower():
  105.     _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
  106. if '_PYTHON_PROJECT_BASE' in os.environ:
  107.     _PROJECT_BASE = os.path.normpath(os.path.abspath('.'))
  108.  
  109. def is_python_build():
  110.     for fn in ('Setup.dist', 'Setup.local'):
  111.         if os.path.isfile(os.path.join(_PROJECT_BASE, 'Modules', fn)):
  112.             return True
  113.     
  114.     return False
  115.  
  116. _PYTHON_BUILD = is_python_build()
  117. if _PYTHON_BUILD:
  118.     for scheme in ('posix_prefix', 'posix_home'):
  119.         _INSTALL_SCHEMES[scheme]['include'] = '{projectbase}/Include'
  120.         _INSTALL_SCHEMES[scheme]['platinclude'] = '{srcdir}'
  121.     
  122.  
  123. def _subst_vars(s, local_vars):
  124.     
  125.     try:
  126.         return s.format(**local_vars)
  127.     except KeyError:
  128.         
  129.         try:
  130.             return s.format(**os.environ)
  131.         except KeyError:
  132.             var = None
  133.             raise AttributeError('{%s}' % var)
  134.         
  135.  
  136.  
  137.  
  138.  
  139. def _extend_dict(target_dict, other_dict):
  140.     target_keys = target_dict.keys()
  141.     for key, value in other_dict.items():
  142.         if key in target_keys:
  143.             continue
  144.         target_dict[key] = value
  145.     
  146.  
  147.  
  148. def _expand_vars(scheme, vars):
  149.     res = { }
  150.     if vars is None:
  151.         vars = { }
  152.     _extend_dict(vars, get_config_vars())
  153.     for key, value in _INSTALL_SCHEMES[scheme].items():
  154.         if os.name in ('posix', 'nt'):
  155.             value = os.path.expanduser(value)
  156.         res[key] = os.path.normpath(_subst_vars(value, vars))
  157.     
  158.     return res
  159.  
  160.  
  161. def _get_default_scheme():
  162.     if os.name == 'posix':
  163.         return 'posix_prefix'
  164.     return None.name
  165.  
  166.  
  167. def _getuserbase():
  168.     env_base = os.environ.get('PYTHONUSERBASE', None)
  169.     
  170.     def joinuser(*args):
  171.         return os.path.expanduser(os.path.join(*args))
  172.  
  173.     if os.name == 'nt':
  174.         if not os.environ.get('APPDATA'):
  175.             pass
  176.         base = '~'
  177.         if env_base:
  178.             return env_base
  179.         return None(base, 'Python')
  180.     if None.platform == 'darwin':
  181.         framework = get_config_var('PYTHONFRAMEWORK')
  182.         if framework:
  183.             if env_base:
  184.                 return env_base
  185.             return None('~', 'Library', framework, '%d.%d' % sys.version_info[:2])
  186.     if env_base:
  187.         return env_base
  188.     return None('~', '.local')
  189.  
  190.  
  191. def _parse_makefile(filename, vars = None):
  192.     '''Parse a Makefile-style file.
  193.  
  194.     A dictionary containing name/value pairs is returned.  If an
  195.     optional dictionary is passed in as the second argument, it is
  196.     used instead of a new dictionary.
  197.     '''
  198.     import re as re
  199.     _variable_rx = re.compile('([a-zA-Z][a-zA-Z0-9_]+)\\s*=\\s*(.*)')
  200.     _findvar1_rx = re.compile('\\$\\(([A-Za-z][A-Za-z0-9_]*)\\)')
  201.     _findvar2_rx = re.compile('\\${([A-Za-z][A-Za-z0-9_]*)}')
  202.     if vars is None:
  203.         vars = { }
  204.     done = { }
  205.     notdone = { }
  206.     with open(filename) as f:
  207.         lines = f.readlines()
  208.     for line in lines:
  209.         if line.startswith('#') or line.strip() == '':
  210.             continue
  211.         m = _variable_rx.match(line)
  212.         if m:
  213.             (n, v) = m.group(1, 2)
  214.             v = v.strip()
  215.             tmpv = v.replace('$$', '')
  216.             if '$' in tmpv:
  217.                 notdone[n] = v
  218.             else:
  219.                 
  220.                 try:
  221.                     v = int(v)
  222.                 except ValueError:
  223.                     done[n] = v.replace('$$', '$')
  224.  
  225.                 done[n] = v
  226.     while notdone:
  227.         for name in notdone.keys():
  228.             value = notdone[name]
  229.             if not _findvar1_rx.search(value):
  230.                 pass
  231.             m = _findvar2_rx.search(value)
  232.             if m:
  233.                 n = m.group(1)
  234.                 found = True
  235.                 if n in done:
  236.                     item = str(done[n])
  237.                 elif n in notdone:
  238.                     found = False
  239.                 elif n in os.environ:
  240.                     item = os.environ[n]
  241.                 else:
  242.                     done[n] = item = ''
  243.                 if found:
  244.                     after = value[m.end():]
  245.                     value = value[:m.start()] + item + after
  246.                     if '$' in after:
  247.                         notdone[name] = value
  248.                     else:
  249.                         
  250.                         try:
  251.                             value = int(value)
  252.                         except ValueError:
  253.                             done[name] = value.strip()
  254.  
  255.                         done[name] = value
  256.                         del notdone[name]
  257.                 
  258.             del notdone[name]
  259.         
  260.     for k, v in done.items():
  261.         if isinstance(v, str):
  262.             done[k] = v.strip()
  263.             continue
  264.     vars.update(done)
  265.     return vars
  266.  
  267.  
  268. def _get_makefile_filename():
  269.     if _PYTHON_BUILD:
  270.         return os.path.join(_PROJECT_BASE, 'Makefile')
  271.     return None.path.join(get_path('platstdlib'), 'config', 'Makefile')
  272.  
  273.  
  274. def _generate_posix_vars():
  275.     '''Generate the Python module containing build-time variables.'''
  276.     import pprint as pprint
  277.     vars = { }
  278.     makefile = _get_makefile_filename()
  279.     
  280.     try:
  281.         _parse_makefile(makefile, vars)
  282.     except IOError:
  283.         e = None
  284.         msg = 'invalid Python installation: unable to open %s' % makefile
  285.         if hasattr(e, 'strerror'):
  286.             msg = msg + ' (%s)' % e.strerror
  287.         raise IOError(msg)
  288.  
  289.     config_h = get_config_h_filename()
  290.     
  291.     try:
  292.         with open(config_h) as f:
  293.             parse_config_h(f, vars)
  294.     except IOError:
  295.         e = None
  296.         msg = 'invalid Python installation: unable to open %s' % config_h
  297.         if hasattr(e, 'strerror'):
  298.             msg = msg + ' (%s)' % e.strerror
  299.         raise IOError(msg)
  300.  
  301.     if _PYTHON_BUILD:
  302.         vars['LDSHARED'] = vars['BLDSHARED']
  303.     name = '_sysconfigdata'
  304.     if 'darwin' in sys.platform:
  305.         import imp as imp
  306.         module = imp.new_module(name)
  307.         module.build_time_vars = vars
  308.         sys.modules[name] = module
  309.     pybuilddir = 'build/lib.%s-%s' % (get_platform(), sys.version[:3])
  310.     if hasattr(sys, 'gettotalrefcount'):
  311.         pybuilddir += '-pydebug'
  312.     
  313.     try:
  314.         os.makedirs(pybuilddir)
  315.     except OSError:
  316.         pass
  317.  
  318.     destfile = os.path.join(pybuilddir, name + '.py')
  319.     with open(destfile, 'wb') as f:
  320.         f.write('# system configuration generated and used by the sysconfig module\n')
  321.         f.write('build_time_vars = ')
  322.         pprint.pprint(vars, stream = f)
  323.     with open('pybuilddir.txt', 'w') as f:
  324.         f.write(pybuilddir)
  325.  
  326.  
  327. def _init_posix(vars):
  328.     '''Initialize the module as appropriate for POSIX systems.'''
  329.     build_time_vars = build_time_vars
  330.     import _sysconfigdata
  331.     vars.update(build_time_vars)
  332.  
  333.  
  334. def _init_non_posix(vars):
  335.     '''Initialize the module as appropriate for NT'''
  336.     vars['LIBDEST'] = get_path('stdlib')
  337.     vars['BINLIBDEST'] = get_path('platstdlib')
  338.     vars['INCLUDEPY'] = get_path('include')
  339.     vars['SO'] = '.pyd'
  340.     vars['EXE'] = '.exe'
  341.     vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
  342.     vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
  343.  
  344.  
  345. def parse_config_h(fp, vars = None):
  346.     '''Parse a config.h-style file.
  347.  
  348.     A dictionary containing name/value pairs is returned.  If an
  349.     optional dictionary is passed in as the second argument, it is
  350.     used instead of a new dictionary.
  351.     '''
  352.     import re
  353.     if vars is None:
  354.         vars = { }
  355.     define_rx = re.compile('#define ([A-Z][A-Za-z0-9_]+) (.*)\n')
  356.     undef_rx = re.compile('/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n')
  357.     while True:
  358.         line = fp.readline()
  359.         if not line:
  360.             break
  361.         m = define_rx.match(line)
  362.         if m:
  363.             (n, v) = m.group(1, 2)
  364.             
  365.             try:
  366.                 v = int(v)
  367.             except ValueError:
  368.                 pass
  369.  
  370.             vars[n] = v
  371.             continue
  372.         m = undef_rx.match(line)
  373.         if m:
  374.             vars[m.group(1)] = 0
  375.             continue
  376.         return vars
  377.  
  378.  
  379. def get_config_h_filename():
  380.     '''Returns the path of pyconfig.h.'''
  381.     if _PYTHON_BUILD:
  382.         if os.name == 'nt':
  383.             inc_dir = os.path.join(_PROJECT_BASE, 'PC')
  384.         else:
  385.             inc_dir = _PROJECT_BASE
  386.     else:
  387.         inc_dir = get_path('platinclude')
  388.     return os.path.join(inc_dir, 'pyconfig.h')
  389.  
  390.  
  391. def get_scheme_names():
  392.     '''Returns a tuple containing the schemes names.'''
  393.     schemes = _INSTALL_SCHEMES.keys()
  394.     schemes.sort()
  395.     return tuple(schemes)
  396.  
  397.  
  398. def get_path_names():
  399.     '''Returns a tuple containing the paths names.'''
  400.     return _SCHEME_KEYS
  401.  
  402.  
  403. def get_paths(scheme = _get_default_scheme(), vars = None, expand = True):
  404.     '''Returns a mapping containing an install scheme.
  405.  
  406.     ``scheme`` is the install scheme name. If not provided, it will
  407.     return the default scheme for the current platform.
  408.     '''
  409.     if expand:
  410.         return _expand_vars(scheme, vars)
  411.     return None[scheme]
  412.  
  413.  
  414. def get_path(name, scheme = _get_default_scheme(), vars = None, expand = True):
  415.     '''Returns a path corresponding to the scheme.
  416.  
  417.     ``scheme`` is the install scheme name.
  418.     '''
  419.     return get_paths(scheme, vars, expand)[name]
  420.  
  421.  
  422. def get_config_vars(*args):
  423.     """With no arguments, return a dictionary of all configuration
  424.     variables relevant for the current platform.
  425.  
  426.     On Unix, this means every variable defined in Python's installed Makefile;
  427.     On Windows and Mac OS it's a much smaller set.
  428.  
  429.     With arguments, return a list of values that result from looking up
  430.     each argument in the configuration variable dictionary.
  431.     """
  432.     global _CONFIG_VARS
  433.     import re
  434.     if _CONFIG_VARS is None:
  435.         _CONFIG_VARS = { }
  436.         _CONFIG_VARS['prefix'] = _PREFIX
  437.         _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
  438.         _CONFIG_VARS['py_version'] = _PY_VERSION
  439.         _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
  440.         _CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]
  441.         _CONFIG_VARS['base'] = _PREFIX
  442.         _CONFIG_VARS['platbase'] = _EXEC_PREFIX
  443.         _CONFIG_VARS['projectbase'] = _PROJECT_BASE
  444.         if os.name in ('nt', 'os2'):
  445.             _init_non_posix(_CONFIG_VARS)
  446.         if os.name == 'posix':
  447.             _init_posix(_CONFIG_VARS)
  448.         _CONFIG_VARS['userbase'] = _getuserbase()
  449.         if 'srcdir' not in _CONFIG_VARS:
  450.             _CONFIG_VARS['srcdir'] = _PROJECT_BASE
  451.         if _PYTHON_BUILD and os.name == 'posix':
  452.             base = _PROJECT_BASE
  453.             
  454.             try:
  455.                 cwd = os.getcwd()
  456.             except OSError:
  457.                 cwd = None
  458.  
  459.             if not os.path.isabs(_CONFIG_VARS['srcdir']) and base != cwd:
  460.                 srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])
  461.                 _CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)
  462.             
  463.         if sys.platform == 'darwin':
  464.             import _osx_support as _osx_support
  465.             _osx_support.customize_config_vars(_CONFIG_VARS)
  466.         
  467.     if args:
  468.         vals = []
  469.         for name in args:
  470.             vals.append(_CONFIG_VARS.get(name))
  471.         
  472.         return vals
  473.     return None
  474.  
  475.  
  476. def get_config_var(name):
  477.     """Return the value of a single variable using the dictionary returned by
  478.     'get_config_vars()'.
  479.  
  480.     Equivalent to get_config_vars().get(name)
  481.     """
  482.     return get_config_vars().get(name)
  483.  
  484.  
  485. def get_platform():
  486.     """Return a string that identifies the current platform.
  487.  
  488.     This is used mainly to distinguish platform-specific build directories and
  489.     platform-specific built distributions.  Typically includes the OS name
  490.     and version and the architecture (as supplied by 'os.uname()'),
  491.     although the exact information included depends on the OS; eg. for IRIX
  492.     the architecture isn't particularly important (IRIX only runs on SGI
  493.     hardware), but for Linux the kernel version isn't particularly
  494.     important.
  495.  
  496.     Examples of returned values:
  497.        linux-i586
  498.        linux-alpha (?)
  499.        solaris-2.6-sun4u
  500.        irix-5.3
  501.        irix64-6.2
  502.  
  503.     Windows will return one of:
  504.        win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
  505.        win-ia64 (64bit Windows on Itanium)
  506.        win32 (all others - specifically, sys.platform is returned)
  507.  
  508.     For other non-POSIX platforms, currently just returns 'sys.platform'.
  509.     """
  510.     import re
  511.     if os.name == 'nt':
  512.         prefix = ' bit ('
  513.         i = sys.version.find(prefix)
  514.         if i == -1:
  515.             return sys.platform
  516.         j = None.version.find(')', i)
  517.         look = sys.version[i + len(prefix):j].lower()
  518.         if look == 'amd64':
  519.             return 'win-amd64'
  520.         if None == 'itanium':
  521.             return 'win-ia64'
  522.         return None.platform
  523.     if None in os.environ:
  524.         return os.environ['_PYTHON_HOST_PLATFORM']
  525.     if None.name != 'posix' or not hasattr(os, 'uname'):
  526.         return sys.platform
  527.     (osname, host, release, version, machine) = None.uname()
  528.     osname = osname.lower().replace('/', '')
  529.     machine = machine.replace(' ', '_')
  530.     machine = machine.replace('/', '-')
  531.     if osname[:5] == 'linux':
  532.         return '%s-%s' % (osname, machine)
  533.     if None[:5] == 'sunos' or release[0] >= '5':
  534.         osname = 'solaris'
  535.         release = '%d.%s' % (int(release[0]) - 3, release[2:])
  536.         bitness = {
  537.             2147483647: '32bit',
  538.             0x7FFFFFFFFFFFFFFFL: '64bit' }
  539.         machine += '.%s' % bitness[sys.maxint]
  540.     
  541.     if osname[:4] == 'irix':
  542.         return '%s-%s' % (osname, release)
  543.     if None[:3] == 'aix':
  544.         return '%s-%s.%s' % (osname, version, release)
  545.     if None[:6] == 'cygwin':
  546.         osname = 'cygwin'
  547.         rel_re = re.compile('[\\d.]+')
  548.         m = rel_re.match(release)
  549.         if m:
  550.             release = m.group()
  551.         
  552.     elif osname[:6] == 'darwin':
  553.         import _osx_support
  554.         (osname, release, machine) = _osx_support.get_platform_osx(get_config_vars(), osname, release, machine)
  555.     return '%s-%s-%s' % (osname, release, machine)
  556.  
  557.  
  558. def get_python_version():
  559.     return _PY_VERSION_SHORT
  560.  
  561.  
  562. def _print_dict(title, data):
  563.     for key, value in enumerate(sorted(data.items())):
  564.         if index == 0:
  565.             print '%s: ' % title
  566.         print '\t%s = "%s"' % (key, value)
  567.     
  568.  
  569.  
  570. def _main():
  571.     '''Display all information sysconfig detains.'''
  572.     if '--generate-posix-vars' in sys.argv:
  573.         _generate_posix_vars()
  574.         return None
  575.     print None % get_platform()
  576.     print 'Python version: "%s"' % get_python_version()
  577.     print 'Current installation scheme: "%s"' % _get_default_scheme()
  578.     print 
  579.     _print_dict('Paths', get_paths())
  580.     print 
  581.     _print_dict('Variables', get_config_vars())
  582.  
  583. if __name__ == '__main__':
  584.     _main()
  585.